home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2001 May / SGI Freeware 2001 May - Disc 2.iso / dist / fw_nas.idb / usr / freeware / include / nas / Alibint.h.z / Alibint.h
C/C++ Source or Header  |  2001-04-12  |  24KB  |  969 lines
  1. /*
  2.  * Copyright 1993 Network Computing Devices, Inc.
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software and
  5.  * its documentation for any purpose is hereby granted without fee, provided
  6.  * that the above copyright notice appear in all copies and that both that
  7.  * copyright notice and this permission notice appear in supporting
  8.  * documentation, and that the name Network Computing Devices, Inc. not be
  9.  * used in advertising or publicity pertaining to distribution of this 
  10.  * software without specific, written prior permission.
  11.  * 
  12.  * THIS SOFTWARE IS PROVIDED 'AS-IS'.  NETWORK COMPUTING DEVICES, INC.,
  13.  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT
  14.  * LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NONINFRINGEMENT.  IN NO EVENT SHALL NETWORK
  16.  * COMPUTING DEVICES, INC., BE LIABLE FOR ANY DAMAGES WHATSOEVER, INCLUDING
  17.  * SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, INCLUDING LOSS OF USE, DATA,
  18.  * OR PROFITS, EVEN IF ADVISED OF THE POSSIBILITY THEREOF, AND REGARDLESS OF
  19.  * WHETHER IN AN ACTION IN CONTRACT, TORT OR NEGLIGENCE, ARISING OUT OF OR IN
  20.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21.  * 
  22.  * $NCDId: @(#)Alibint.h,v 1.20 1995/12/28 19:44:51 greg Exp $
  23.  */
  24.  
  25. /* Portions derived from */
  26. /* $XConsortium: Xlibint.h,v 11.96 92/01/30 10:22:57 rws Exp $ */
  27. /* Copyright 1984, 1985, 1987, 1989  Massachusetts Institute of Technology */
  28.  
  29. /*
  30. Permission to use, copy, modify, distribute, and sell this software and its
  31. documentation for any purpose is hereby granted without fee, provided that
  32. the above copyright notice appear in all copies and that both that
  33. copyright notice and this permission notice appear in supporting
  34. documentation, and that the name of M.I.T. not be used in advertising or
  35. publicity pertaining to distribution of the software without specific,
  36. written prior permission.  M.I.T. makes no representations about the
  37. suitability of this software for any purpose.  It is provided "as is"
  38. without express or implied warranty.
  39. */
  40.  
  41. /*
  42.  *    Xlibint.h - Header definition and support file for the internal
  43.  *    support routines used by the C subroutine interface
  44.  *    library (Xlib) to the X Window System.
  45.  *
  46.  *    Warning, there be dragons here....
  47.  */
  48.  
  49. #ifndef _NCD_ALIBINT_H_
  50. #define _NCD_ALIBINT_H_
  51.  
  52. #include <nas/audiolib.h>
  53.  
  54. /* round up to a four byte boundary */
  55. #define PAD4(x)                (((x) + 3) & ~3)
  56.  
  57. /* useful macros for transfering attributes */
  58. #define _xfer(s, d, x)    (d).x = (s).x
  59.  
  60. #define _xferCommonPart(s, d)                               \
  61. {                                           \
  62.     _xfer(s, d, value_mask);                               \
  63.     _xfer(s, d, changable_mask);                           \
  64.     _xfer(s, d, id);                                   \
  65.     _xfer(s, d, kind);                                   \
  66.     _xfer(s, d, use);                                   \
  67.     _xfer(s, d, format);                               \
  68.     _xfer(s, d, num_tracks);                               \
  69.     _xfer(s, d, access);                               \
  70.     _xfer((s).description, (d).description, type);                   \
  71.     _xfer((s).description, (d).description, len);                   \
  72. }
  73.  
  74. #define _xferDevicePart(s, d)                               \
  75. {                                           \
  76.     _xfer(s, d, min_sample_rate);                           \
  77.     _xfer(s, d, max_sample_rate);                           \
  78.     _xfer(s, d, location);                               \
  79.     _xfer(s, d, gain);                                   \
  80.     _xfer(s, d, line_mode);                               \
  81.     _xfer(s, d, num_children);                               \
  82. }
  83.  
  84. #define _xferBucketPart(s, d)                               \
  85. {                                           \
  86.     _xfer(s, d, sample_rate);                               \
  87.     _xfer(s, d, num_samples);                               \
  88. }
  89.  
  90. #define _xferDeviceAttributes(s, d)                           \
  91. {                                           \
  92.     _xferCommonPart((s)->common, (d).common);                       \
  93.     _xferDevicePart((s)->device, (d).device);                       \
  94. }
  95.  
  96. #define _xferBucketAttributes(s, d)                           \
  97. {                                           \
  98.     _xferCommonPart((s)->common, (d).common);                       \
  99.     _xferBucketPart((s)->bucket, (d).bucket);                       \
  100. }
  101.  
  102. /*
  103.  * define the following if you want the _AuData macro to be a procedure instead
  104.  */
  105. #ifdef CRAY
  106. #define _AuDataRoutineIsProcedure
  107. #endif /* CRAY */
  108.  
  109. /*
  110.  * _QEvent datatype for use in input queueing.
  111.  */
  112. typedef struct _AuSQEvent {
  113.     struct _AuSQEvent *next;
  114.     AuEvent event;
  115. } _AuQEvent;
  116.  
  117. #include <stdio.h>
  118. #include <nas/Aproto.h>
  119. #include <errno.h>
  120. #define _AUBCOPYFUNC _Aubcopy
  121. #include <nas/Afuncs.h>
  122. #include <nas/Aosdefs.h>
  123.  
  124. /* Utek leaves kernel macros around in include files (bleah) */
  125. #ifdef dirty
  126. #undef dirty
  127. #endif
  128.  
  129. #ifdef CRAY
  130. #define WORD64
  131. #endif
  132.  
  133. #ifndef AU_NOT_STDC_ENV
  134. # include <stdlib.h>
  135. # include <string.h>
  136. #else
  137. # ifndef hpux
  138.    extern char *malloc(), *realloc(), *calloc();
  139. # endif
  140. void exit();
  141. #ifdef SYSV
  142. #include <string.h>
  143. #else
  144. #include <strings.h>
  145. #endif
  146. #endif
  147. #if defined(macII) && !defined(__STDC__)  /* stdlib.h fails to define these */
  148. extern char *malloc(), *realloc(), *calloc();
  149. #endif /* macII */
  150.  
  151. /*
  152.  * The following definitions can be used for locking requests in multi-threaded
  153.  * address spaces.
  154.  */
  155. #define _AuLockServer(aud)
  156. #define _AuLockMutex(mutex)
  157. #define _AuUnlockMutex(mutex)
  158. #define _AuUnlockServer(aud)
  159. #define Aufree(ptr) free((ptr))
  160.  
  161. /*
  162.  * Note that some machines do not return a valid pointer for malloc(0), in
  163.  * which case we provide an alternate under the control of the
  164.  * define MALLOC_0_RETURNS_NULL.  This is necessary because some
  165.  * Aulib code expects malloc(0) to return a valid pointer to storage.
  166.  */
  167. #ifdef MALLOC_0_RETURNS_NULL
  168.  
  169. # define Aumalloc(size) malloc(((size) > 0 ? (size) : 1))
  170. # define Aurealloc(ptr, size) realloc((ptr), ((size) > 0 ? (size) : 1))
  171. # define Aucalloc(nelem, elsize) calloc(((nelem) > 0 ? (nelem) : 1), (elsize))
  172.  
  173. #else
  174.  
  175. # define Aumalloc(size) malloc((size))
  176. # define Aurealloc(ptr, size) realloc((ptr), (size))
  177. # define Aucalloc(nelem, elsize) calloc((nelem), (elsize))
  178.  
  179. #endif /* MALLOC_0_RETURNS_NULL */
  180.  
  181. #ifndef NULL
  182. #define NULL 0
  183. #endif
  184. #define LOCKED 1
  185. #define UNLOCKED 0
  186.  
  187. #ifdef notdef
  188. extern int errno;            /* Internal system error number. */
  189. #endif
  190.  
  191. #ifndef BUFSIZE
  192. #define BUFSIZE 2048            /* Au output buffer size. */
  193. #endif
  194.  
  195. /*
  196.  * display flags
  197.  */
  198. #define AuServerFlagsIOError    (1L << 0)
  199. #define AuServerFlagsClosing    (1L << 1)
  200.  
  201. /*
  202.  * Au Protocol packetizing macros.
  203.  */
  204.  
  205. /*   Need to start requests on 64 bit word boundries
  206.  *   on a CRAY computer so add a NoOp (127) if needed.
  207.  *   A character pointer on a CRAY computer will be non-zero
  208.  *   after shifting right 61 bits of it is not pointing to
  209.  *   a word boundary.
  210.  */
  211. #ifdef WORD64
  212. #define WORD64ALIGN if ((AuInt32)aud->bufptr >> 61) {\
  213.            aud->last_req = aud->bufptr;\
  214.            *(aud->bufptr)   = Au_NoOperation;\
  215.            *(aud->bufptr+1) =  0;\
  216.            *(aud->bufptr+2) =  0;\
  217.            *(aud->bufptr+3) =  1;\
  218.              aud->request++;\
  219.              aud->bufptr += 4;\
  220.          }
  221. #else /* else does not require alignment on 64-bit boundaries */
  222. #define WORD64ALIGN
  223. #endif /* WORD64 */
  224.  
  225.  
  226. /*
  227.  * _AuGetReq - Get the next avilable Au request packet in the buffer and
  228.  * return it. 
  229.  *
  230.  * "name" is the name of the request, e.g. CreatePixmap, OpenFont, etc.
  231.  * "req" is the name of the request pointer.
  232.  *
  233.  */
  234. #ifdef UNIXCPP
  235. #error "bummer"
  236. #endif
  237. #if defined(__STDC__) && !defined(UNIXCPP)
  238. #define _AuGetReq(name, req, aud) \
  239.         WORD64ALIGN\
  240.     if ((aud->bufptr + SIZEOF(au##name##Req)) > aud->bufmax)\
  241.         _AuFlush(aud);\
  242.     req = (au##name##Req *)(aud->last_req = aud->bufptr);\
  243.     req->reqType = Au_##name;\
  244.     req->length = (SIZEOF(au##name##Req))>>2;\
  245.     aud->bufptr += SIZEOF(au##name##Req);\
  246.     aud->request++
  247.  
  248. #else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
  249. #define _AuGetReq(name, req, aud) \
  250.         WORD64ALIGN\
  251.     if ((aud->bufptr + SIZEOF(au/**/name/**/Req)) > aud->bufmax)\
  252.         _AuFlush(aud);\
  253.     req = (au/**/name/**/Req *)(aud->last_req = aud->bufptr);\
  254.     req->reqType = Au_/**/name;\
  255.     req->length = (SIZEOF(au/**/name/**/Req))>>2;\
  256.     aud->bufptr += SIZEOF(au/**/name/**/Req);\
  257.     aud->request++
  258. #endif
  259.  
  260. /* _AuGetReqExtra is the same as _AuGetReq, but allocates "n" additional
  261.    bytes after the request. "n" must be a multiple of 4!  */
  262.  
  263. #if  defined(__STDC__) && !defined(UNIXCPP)
  264. #define _AuGetReqExtra(name, n, req, aud) \
  265.         WORD64ALIGN\
  266.     if ((aud->bufptr + SIZEOF(au##name##Req) + n) > aud->bufmax)\
  267.         _AuFlush(aud);\
  268.     req = (au##name##Req *)(aud->last_req = aud->bufptr);\
  269.     req->reqType = Au_##name;\
  270.     req->length = (SIZEOF(au##name##Req) + n)>>2;\
  271.     aud->bufptr += SIZEOF(au##name##Req) + n;\
  272.     aud->request++
  273. #else
  274. #define _AuGetReqExtra(name, n, req, aud) \
  275.         WORD64ALIGN\
  276.     if ((aud->bufptr + SIZEOF(au/**/name/**/Req) + n) > aud->bufmax)\
  277.         _AuFlush(aud);\
  278.     req = (au/**/name/**/Req *)(aud->last_req = aud->bufptr);\
  279.     req->reqType = Au_/**/name;\
  280.     req->length = (SIZEOF(au/**/name/**/Req) + n)>>2;\
  281.     aud->bufptr += SIZEOF(au/**/name/**/Req) + n;\
  282.     aud->request++
  283. #endif
  284.  
  285.  
  286. /*
  287.  * _AuGetResReq is for those requests that have a resource ID 
  288.  * (Window, Pixmap, GContext, etc.) as their single argument.
  289.  * "rid" is the name of the resource. 
  290.  */
  291.  
  292. #if  defined(__STDC__) && !defined(UNIXCPP)
  293. #define _AuGetResReq(name, rid, req, aud) \
  294.         WORD64ALIGN\
  295.     if ((aud->bufptr + SIZEOF(auResourceReq)) > aud->bufmax)\
  296.         _AuFlush(aud);\
  297.     req = (auResourceReq *) (aud->last_req = aud->bufptr);\
  298.     req->reqType = Au_##name;\
  299.     req->length = 2;\
  300.     req->id = (rid);\
  301.     aud->bufptr += SIZEOF(auResourceReq);\
  302.     aud->request++
  303. #else
  304. #define _AuGetResReq(name, rid, req, aud) \
  305.         WORD64ALIGN\
  306.     if ((aud->bufptr + SIZEOF(auResourceReq)) > aud->bufmax)\
  307.         _AuFlush(aud);\
  308.     req = (auResourceReq *) (aud->last_req = aud->bufptr);\
  309.     req->reqType = Au_/**/name;\
  310.     req->length = 2;\
  311.     req->id = (rid);\
  312.     aud->bufptr += SIZEOF(auResourceReq);\
  313.     aud->request++
  314. #endif
  315.  
  316. /*
  317.  * _AuGetEmptyReq is for those requests that have no arguments
  318.  * at all. 
  319.  */
  320. #if  defined(__STDC__) && !defined(UNIXCPP)
  321. #define _AuGetEmptyReq(name, req, aud) \
  322.         WORD64ALIGN\
  323.     if ((aud->bufptr + SIZEOF(auReq)) > aud->bufmax)\
  324.         _AuFlush(aud);\
  325.     req = (auReq *) (aud->last_req = aud->bufptr);\
  326.     req->reqType = Au_##name;\
  327.     req->length = 1;\
  328.     aud->bufptr += SIZEOF(auReq);\
  329.     aud->request++
  330. #else
  331. #define _AuGetEmptyReq(name, req, aud) \
  332.         WORD64ALIGN\
  333.     if ((aud->bufptr + SIZEOF(auReq)) > aud->bufmax)\
  334.         _AuFlush(aud);\
  335.     req = (auReq *) (aud->last_req = aud->bufptr);\
  336.     req->reqType = Au_/**/name;\
  337.     req->length = 1;\
  338.     aud->bufptr += SIZEOF(auReq);\
  339.     aud->request++
  340. #endif
  341.  
  342.  
  343. #define _AuSyncHandle(aud) \
  344.     if (aud->synchandler) _AuDoSyncHandle(aud)
  345.  
  346. /*
  347.  * _AuData - Place data in the buffer and pad the end to provide
  348.  * 32 bit word alignment.  Transmit if the buffer fills.
  349.  *
  350.  * "aud" is a pointer to a AuServer.
  351.  * "data" is a pinter to a data buffer.
  352.  * "len" is the length of the data buffer.
  353.  * we can presume buffer less than 2^16 bytes, so bcopy can be used safely.
  354.  */
  355. #ifndef _AuDataRoutineIsProcedure
  356. #define _AuData(aud, data, len) \
  357.     if (aud->bufptr + (len) <= aud->bufmax) {\
  358.         bcopy(data, aud->bufptr, (int)len);\
  359.         aud->bufptr += ((len) + 3) & ~3;\
  360.     } else\
  361.         _AuSend(aud, data, len)
  362. #endif /* _AuDataRoutineIsProcedure */
  363.  
  364.  
  365. /* Allocate bytes from the buffer.  No padding is done, so if
  366.  * the length is not a multiple of 4, the caller must be
  367.  * careful to leave the buffer aligned after sending the
  368.  * current request.
  369.  *
  370.  * "type" is the type of the pointer being assigned to.
  371.  * "ptr" is the pointer being assigned to.
  372.  * "n" is the number of bytes to allocate.
  373.  *
  374.  * Example: 
  375.  *    xTextElt *elt;
  376.  *    BufAlloc (xTextElt *, elt, nbytes)
  377.  */
  378.  
  379. #define BufAlloc(type, ptr, n) \
  380.     if (aud->bufptr + (n) > aud->bufmax) \
  381.         _AuFlush (aud); \
  382.     ptr = (type) aud->bufptr; \
  383.     aud->bufptr += (n);
  384.  
  385. /*
  386.  * provide emulation routines for smaller architectures
  387.  */
  388. #ifndef WORD64
  389. #define _AuData16(aud, data, len) _AuData((aud), (char *)(data), (len))
  390. #define _AuData32(aud, data, len) _AuData((aud), (char *)(data), (len))
  391. #define _AuRead16Pad(aud, data, len) _AuReadPad((aud), (char *)(data), (len))
  392. #define _AuRead16(aud, data, len) _AuRead((aud), (char *)(data), (len))
  393. #define _AuRead32(aud, data, len) _AuRead((aud), (char *)(data), (len))
  394. #endif /* not WORD64 */
  395.  
  396. #define _AuPackData16(aud,data,len) _AuData16 (aud, data, len)
  397. #define _AuPackData32(aud,data,len) _AuData32 (aud, data, len)
  398.  
  399. /* Xlib manual is bogus */
  400. #define _AuPackData(aud,data,len) _AuPackData16 (aud, data, len)
  401.  
  402. #define aumin(a,b) (((a) < (b)) ? (a) : (b))
  403. #define aumax(a,b) (((a) > (b)) ? (a) : (b))
  404.  
  405. #ifdef MUSTCOPY
  406.  
  407. /* for when 32-bit alignment is not good enough */
  408. #define _AuOneDataCard32(aud,dstaddr,srcvar) \
  409.   { aud->bufptr -= 4; _AuData32 (aud, (char *) &(srcvar), 4); }
  410.  
  411. #else
  412.  
  413. /* srcvar must be a variable for large architecture version */
  414. #define _AuOneDataCard32(aud,dstaddr,srcvar) \
  415.   { *(AuUint32 *)(dstaddr) = (srcvar); }
  416.  
  417. #endif /* MUSTCOPY */
  418.  
  419. typedef struct _AuInternalAsync {
  420.     struct _AuInternalAsync *next;
  421.     AuBool (*handler)();
  422.     AuPointer data;
  423. } _AuAsyncHandler;
  424.  
  425. typedef struct _AuAsyncEState {
  426.     AuUint32 min_sequence_number;
  427.     AuUint32 max_sequence_number;
  428.     unsigned char error_code;
  429.     unsigned char major_opcode;
  430.     unsigned short minor_opcode;
  431.     unsigned char last_error_received;
  432.     int error_count;
  433. } _AuAsyncErrorState;
  434.  
  435. #define _AuEnqAsyncHandler(aud,hhh,ppp,ddd) { \
  436.     (hhh)->next = (aud)->async_handlers; \
  437.     (hhh)->handler = (ppp); \
  438.     (hhh)->data = (AuPointer) (ddd); \
  439.     (aud)->async_handlers = (hhh); \
  440.     }
  441.  
  442. #define _AuDeqAsyncHandler(aud,handler) { \
  443.     if (aud->async_handlers == (handler)) \
  444.     aud->async_handlers = (handler)->next; \
  445.     else \
  446.     _AuDoDeqAsyncHandler(aud, handler); \
  447.     }
  448.  
  449.  
  450. /*
  451.  * This structure is private to the library.
  452.  */
  453. typedef struct _AuExten {    /* private to extension mechanism */
  454.     struct _AuExten *next;    /* next in list */
  455.     AuExtCodes codes;    /* public information, all extension told */
  456.     int (*close_server)(    /* routine to call when connection closed */
  457. #if NeedNestedPrototypes
  458.         AuServer *,        /* server */
  459.         AuExtCodes *    /* extensioncodes */
  460. #endif
  461.     );
  462.     AuBool (*error)(    /* who to call when an error occurs */
  463. #if NeedNestedPrototypes
  464.         AuServer *,        /* server */
  465.         auError *,        /* errorpacket */
  466.         AuExtCodes *,    /* extensioncodes */
  467.         AuBool *        /* returncode */
  468. #endif
  469.     );
  470.         char *(*error_string)(  /* routine to supply error string */
  471. #if NeedNestedPrototypes
  472.         AuServer *,        /* server */
  473.         int,        /* errorcode */
  474.         AuExtCodes *,    /* extensioncodes */
  475.         char *,        /* buffer */
  476.         int            /* bufsiz */
  477. #endif
  478.     );
  479.     char *name;        /* name of this extension */
  480.     void (*error_values)( /* routine to supply error values */
  481. #if NeedNestedPrototypes
  482.         AuServer *,        /* server */
  483.         AuErrorEvent *,    /* event */
  484.         FILE *        /* where to print */
  485. #endif
  486.     );
  487. } _AuExtension;
  488.  
  489.  
  490. #define _AuAddToLinkedList(head, item)                           \
  491. {                                           \
  492.     (item)->prev = NULL;                               \
  493.     (item)->next = head;                               \
  494.     if (head)                                       \
  495.     (head)->prev = item;                               \
  496.     head = item;                                   \
  497. }
  498.  
  499. #define _AuRemoveFromLinkedList(head, item)                       \
  500. {                                           \
  501.     if ((item)->next)                                   \
  502.     (item)->next->prev = (item)->prev;                       \
  503.                                            \
  504.     if ((item)->prev)                                   \
  505.     (item)->prev->next = (item)->next;                       \
  506.     else                                       \
  507.     head = (item)->next;                               \
  508. }
  509.  
  510. /* extension hooks */
  511.  
  512. _AUFUNCPROTOBEGIN
  513.  
  514. /**********************/
  515. /* Internal functions */
  516. /**********************/
  517.  
  518. extern int _AuDefaultError(
  519. #if NeedFunctionPrototypes
  520.     AuServer *,
  521.     AuErrorEvent *
  522. #endif
  523. );
  524.  
  525. extern void
  526. _AuDefaultIOError (
  527. #if NeedFunctionPrototypes
  528.     AuServer *
  529. #endif
  530. );
  531.  
  532. extern AuBool _AuWireToEvent(
  533. #if NeedFunctionPrototypes
  534.     AuServer *,    /* server */
  535.     AuEvent *,    /* pointer to where event should be reformatted */
  536.     auEvent *    /* wire protocol event */
  537. #endif
  538. );
  539.  
  540. extern AuBool _AuUnknownWireEvent(
  541. #if NeedFunctionPrototypes
  542.     AuServer *,    /* server */
  543.     AuEvent *,    /* pointer to where event should be reformatted */
  544.     auEvent *    /* wire protocol event */
  545. #endif
  546. );
  547.  
  548. extern AuStatus _AuUnknownNativeEvent(
  549. #if NeedFunctionPrototypes
  550.     AuServer *,    /* server */
  551.     AuEvent *,    /* pointer to where event should be reformatted */
  552.     auEvent *    /* wire protocol event */
  553. #endif
  554. );
  555.  
  556. extern AuID _AuAllocID (
  557. #if NeedFunctionPrototypes
  558.     AuServer *        /* server */
  559. #endif
  560. );
  561.  
  562. #ifdef _AuDataRoutineIsProcedure
  563. extern void _AuData(
  564. #if NeedFunctionPrototypes
  565.     AuServer *,        /* server */
  566.     char *,        /* data */
  567.     AuInt32        /* len */
  568. #endif
  569. );
  570. #endif
  571.  
  572. extern int _AuError (            /* prepare to upcall user handler */
  573. #if NeedFunctionPrototypes
  574.     AuServer *,        /* server */
  575.     auError *        /* reply */
  576. #endif
  577. );
  578. extern int _AuIOError (            /* prepare to upcall user handler */
  579. #if NeedFunctionPrototypes
  580.     AuServer *        /* server */
  581. #endif
  582. );
  583.  
  584. extern void _AuEatData (        /* swallow data from server */
  585. #if NeedFunctionPrototypes
  586.     AuServer *,        /* server */
  587.     AuUint32    /* nbytes */
  588. #endif
  589. );
  590.  
  591. extern char *_AuAllocScratch (        /* fast memory allocator */
  592. #if NeedFunctionPrototypes
  593.     AuServer *,        /* server */
  594.     AuUint32    /* nbytes */
  595. #endif
  596. );
  597.  
  598. extern AuUint32 _AuSetLastRequestRead(    /* update aud->last_request_read */
  599. #if NeedFunctionPrototypes
  600.     AuServer *,        /* server */
  601.     auGenericReply *    /* reply */
  602. #endif
  603. );
  604.  
  605. extern int _AuGetHostname (        /* get name of this machine */
  606. #if NeedFunctionPrototypes
  607.     char *,        /* buf */
  608.     int            /* len */
  609. #endif
  610. );
  611.  
  612. extern AuBool _AuAsyncErrorHandler (    /* internal error handler */
  613. #if NeedFunctionPrototypes
  614.     AuServer *,        /* server */
  615.     auReply *,        /* reply */
  616.     char *,        /* buf */
  617.     int,        /* len */
  618.     AuPointer        /* data */
  619. #endif
  620. );
  621.  
  622. extern void _AuDoDeqAsyncHandler (
  623. #if NeedFunctionPrototypes
  624.     AuServer *,        /* server */
  625.     _AuAsyncHandler *    /* handler */
  626. #endif
  627. );
  628.  
  629. extern char *_AuGetAsyncReply (        /* get async reply */
  630. #if NeedFunctionPrototypes
  631.     AuServer *,        /* server */
  632.     char *,        /* replbuf */
  633.     auReply *,        /* rep */
  634.     char *,        /* buf */
  635.     int,        /* len */
  636.     int,        /* extra */
  637.     AuBool        /* discard */
  638. #endif
  639. );
  640.  
  641. extern AuBool _AuReply (
  642. #if NeedFunctionPrototypes
  643.     AuServer *,        /* server */
  644.     auReply *,        /* reply */
  645.     int,        /* extra */
  646.     AuBool,        /* discard */
  647.     AuStatus *        /* ret_status */
  648. #endif
  649. );
  650.  
  651. extern AuBool _AuForceRoundTrip (
  652. #if NeedFunctionPrototypes
  653.     AuServer *,        /* server */
  654.     int,        /* error_code */
  655.     int,        /* major */
  656.     int,        /* minor */
  657.     AuStatus *        /* ret_status */
  658. #endif
  659. );
  660.  
  661. #define _AuIfRoundTrip(aud,rsp) \
  662.     (rsp ? _AuForceRoundTrip (aud, 0, 0, 0, (rsp)) : AuTrue)
  663.  
  664. extern int _AuPrintDefaultError (
  665. #if NeedFunctionPrototypes
  666.     AuServer *,        /* server */
  667.     AuErrorEvent *,    /* event */
  668.     FILE *        /* fp */
  669. #endif
  670. );
  671.  
  672. extern void _AuFreeQ (
  673. #if NeedFunctionPrototypes
  674.     AuServer *        /* server */
  675. #endif
  676. );
  677.  
  678. extern void _AuDoSyncHandle (
  679. #if NeedFunctionPrototypes
  680.     AuServer *        /* server */
  681. #endif
  682. );
  683.  
  684. extern void
  685. _AuAddToBucketCache(
  686. #if NeedFunctionPrototypes
  687.              AuServer *,        /* server */
  688.              AuBucketAttributes *    /* bucket attributes */
  689. #endif
  690. );
  691.  
  692. extern AuBucketAttributes *
  693. _AuLookupBucketInCache(
  694. #if NeedFunctionPrototypes
  695.              AuServer *,        /* server */
  696.              AuBucketID        /* bucket */
  697. #endif
  698. );
  699.  
  700. extern void
  701. _AuRemoveFromBucketCache(
  702. #if NeedFunctionPrototypes
  703.              AuServer *,        /* server */
  704.              AuBucketID        /* bucket */
  705. #endif
  706. );
  707.  
  708. extern void
  709. _AuFreeBucketCache(
  710. #if NeedFunctionPrototypes
  711.              AuServer *        /* server */
  712. #endif
  713. );
  714.  
  715. extern void
  716. _AuRead(
  717. #if NeedFunctionPrototypes
  718.         AuServer *,        /* server */
  719.     char *,            /* data */
  720.     AuInt32            /* size */
  721. #endif
  722. );
  723.  
  724. void
  725. _AuReadPad(
  726. #if NeedFunctionPrototypes
  727.         AuServer *,        /* server */
  728.     char *,            /* data */
  729.     AuInt32            /* size */
  730. #endif
  731. );
  732.  
  733. extern void
  734. _AuSend(
  735. #if NeedFunctionPrototypes
  736.         AuServer *,        /* server */
  737.     char *,            /* data */
  738.     AuInt32            /* size */
  739. #endif
  740. );
  741.  
  742. extern void
  743. _AuFreeExtData(
  744. #if NeedFunctionPrototypes
  745.     AuExtData *            /* extension */
  746. #endif
  747. );
  748.  
  749. extern int
  750. _AuDisconnectServer(
  751. #if NeedFunctionPrototypes
  752.     int                /* server */
  753. #endif
  754. );
  755.  
  756. void
  757. _AuFreeServerStructure(
  758. #if NeedFunctionPrototypes
  759.     AuServer  *            /* aud */
  760. #endif
  761. );
  762.  
  763. void
  764. _AuFlush(
  765. #if NeedFunctionPrototypes
  766.     AuServer  *            /* aud */
  767. #endif
  768. );
  769.  
  770. int
  771. _AuEventsQueued(
  772. #if NeedFunctionPrototypes
  773.     AuServer  *,         /* aud */
  774.     int                /* mode */
  775. #endif
  776. );
  777.  
  778. void
  779. _AuReadEvents(
  780. #if NeedFunctionPrototypes
  781.     AuServer  *         /* aud */
  782. #endif
  783. );
  784.  
  785. int
  786. _AuConnectServer(
  787. #if NeedFunctionPrototypes
  788.     _AuConst char *,         /* server_name */
  789.     char **,             /* fullnamep */
  790.     int *,             /* svrnump */
  791.     char **,             /* auth_namep */
  792.     int *,             /* auth_namelenp */
  793.     char **,             /* auth_datap */
  794.     int *             /* auth_datalenp */
  795. #endif
  796. );
  797.  
  798. /********************/
  799. /* Public functions */
  800. /********************/
  801.  
  802. extern int (*AuESetCloseServer(
  803. #if NeedFunctionPrototypes
  804.     AuServer*        /* server */,
  805.     int            /* extension */,
  806.     int (*) (
  807. #if NeedNestedPrototypes
  808.           AuServer*            /* server */,
  809.               AuExtCodes*        /* codes */
  810. #endif
  811.             )        /* proc */    
  812. #endif
  813. ))(
  814. #if NeedNestedPrototypes
  815.     AuServer*, AuExtCodes*
  816. #endif
  817. );
  818.  
  819. extern int (*AuESetError(
  820. #if NeedFunctionPrototypes
  821.     AuServer*        /* server */,
  822.     int            /* extension */,
  823.     int (*) (
  824. #if NeedNestedPrototypes
  825.           AuServer*            /* server */,
  826.               auError*            /* err */,
  827.               AuExtCodes*        /* codes */,
  828.               int*            /* ret_code */
  829. #endif
  830.             )        /* proc */    
  831. #endif
  832. ))(
  833. #if NeedNestedPrototypes
  834.     AuServer*, auError*, AuExtCodes*, int*
  835. #endif
  836. );
  837.  
  838. extern char* (*AuESetErrorString(
  839. #if NeedFunctionPrototypes
  840.     AuServer*        /* server */,
  841.     int            /* extension */,
  842.     char* (*) (
  843. #if NeedNestedPrototypes
  844.             AuServer*        /* server */,
  845.                 int            /* code */,
  846.                 AuExtCodes*        /* codes */,
  847.                 char*            /* buffer */,
  848.                 int            /* nbytes */
  849. #endif
  850.               )        /* proc */           
  851. #endif
  852. ))(
  853. #if NeedNestedPrototypes
  854.     AuServer*, int, AuExtCodes*, char*, int
  855. #endif
  856. );
  857.  
  858. extern void (*AuESetPrintErrorValues (
  859. #if NeedFunctionPrototypes
  860.     AuServer*        /* server */,
  861.     int            /* extension */,
  862.     void (*)(
  863. #if NeedNestedPrototypes
  864.           AuServer*            /* server */,
  865.           AuErrorEvent*        /* ev */,
  866.           void*            /* fp */
  867. #endif
  868.          )        /* proc */
  869. #endif
  870. ))(
  871. #if NeedNestedPrototypes
  872.     AuServer*, AuErrorEvent*, void*
  873. #endif
  874. );
  875.  
  876. extern int (*AuESetWireToEvent(
  877. #if NeedFunctionPrototypes
  878.     AuServer*        /* server */,
  879.     int            /* event_number */,
  880.     AuBool (*) (
  881. #if NeedNestedPrototypes
  882.            AuServer*        /* server */,
  883.                AuEvent*            /* re */,
  884.                auEvent*            /* event */
  885. #endif
  886.              )        /* proc */    
  887. #endif
  888. ))(
  889. #if NeedNestedPrototypes
  890.     AuServer*, AuEvent*, auEvent*
  891. #endif
  892. );
  893.  
  894. extern AuStatus (*AuESetEventToWire(
  895. #if NeedFunctionPrototypes
  896.     AuServer*        /* server */,
  897.     int            /* event_number */,
  898.     int (*) (
  899. #if NeedNestedPrototypes
  900.           AuServer*            /* server */,
  901.               AuEvent*            /* re */,
  902.               auEvent*            /* event */
  903. #endif
  904.             )        /* proc */   
  905. #endif
  906. ))(
  907. #if NeedNestedPrototypes
  908.     AuServer*, AuEvent*, auEvent*
  909. #endif
  910. );
  911.  
  912. extern AuStatus (*AuESetWireToError(
  913. #if NeedFunctionPrototypes
  914.     AuServer*        /* server */,
  915.     int            /* error_number */,
  916.     AuBool (*) (
  917. #if NeedNestedPrototypes
  918.            AuServer*        /* server */,
  919.            AuErrorEvent*        /* he */,
  920.            auError*            /* we */
  921. #endif
  922.             )        /* proc */   
  923. #endif
  924. ))(
  925. #if NeedNestedPrototypes
  926.     AuServer*, AuErrorEvent*, auError*
  927. #endif
  928. );
  929.  
  930. extern AuSyncHandlerRec *
  931. AuRegisterSyncHandler(
  932. #if NeedFunctionPrototypes
  933.               AuServer *,        /* server */
  934.               AuSyncHandlerCallback,    /* callback */
  935.               AuPointer            /* data */
  936. #endif
  937. );
  938.  
  939. extern void
  940. AuUnregisterSyncHandler(
  941. #if NeedFunctionPrototypes
  942.             AuServer *,        /* server */
  943.             AuSyncHandlerRec *    /* handler */
  944. #endif
  945. );
  946.  
  947. extern AuEventEnqHandlerRec *
  948. AuRegisterEventEnqHandler
  949. (
  950. #if NeedFunctionPrototypes
  951.               AuServer *,        /* server */
  952.                int,            /* who */
  953.               AuEventEnqHandlerCallback,/* callback */
  954.               AuPointer            /* data */
  955. #endif
  956. );
  957.  
  958. extern void
  959. AuUnregisterEventEnqHandler(
  960. #if NeedFunctionPrototypes
  961.             AuServer *,        /* server */
  962.             AuEventEnqHandlerRec *    /* handler */
  963. #endif
  964. );
  965.  
  966. _AUFUNCPROTOEND
  967.  
  968. #endif /* _NCD_ALIBINT_H_ */
  969.